home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Python 1.4 / Python 1.4 source / Mac / Modules / macfs / macfsmodule.c next >
Encoding:
C/C++ Source or Header  |  1996-09-20  |  20.9 KB  |  966 lines  |  [TEXT/CWIE]
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI not be used in advertising or publicity pertaining to
  13. distribution of the software without specific, written prior permission.
  14.  
  15. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. #include "allobjects.h"
  26. #include "modsupport.h"        /* For getargs() etc. */
  27. #include "macglue.h"
  28.  
  29. #include <Memory.h>
  30. #include <Files.h>
  31. #include <Folders.h>
  32. #include <StandardFile.h>
  33. #include <Aliases.h>
  34. #include <LowMem.h>
  35.  
  36. #include "nfullpath.h"
  37. #include "getapplbycreator.h"
  38.  
  39. #ifdef THINK_C
  40. #define FileFilterUPP FileFilterProcPtr
  41. #endif
  42.  
  43. static object *ErrorObject;
  44.  
  45. /* ----------------------------------------------------- */
  46. /* Declarations for objects of type Alias */
  47.  
  48. typedef struct {
  49.     OB_HEAD
  50.     AliasHandle alias;
  51. } mfsaobject;
  52.  
  53. staticforward typeobject Mfsatype;
  54.  
  55. #define is_mfsaobject(v)        ((v)->ob_type == &Mfsatype)
  56.  
  57. /* ---------------------------------------------------------------- */
  58. /* Declarations for objects of type FSSpec */
  59.  
  60. typedef struct {
  61.     OB_HEAD
  62.     FSSpec fsspec;
  63. } mfssobject;
  64.  
  65. staticforward typeobject Mfsstype;
  66.  
  67. #define is_mfssobject(v)        ((v)->ob_type == &Mfsstype)
  68.  
  69.  
  70. /* ---------------------------------------------------------------- */
  71. /* Declarations for objects of type FInfo */
  72.  
  73. typedef struct {
  74.     OB_HEAD
  75.     FInfo finfo;
  76. } mfsiobject;
  77.  
  78. staticforward typeobject Mfsitype;
  79.  
  80. #define is_mfsiobject(v)        ((v)->ob_type == &Mfsitype)
  81.  
  82.  
  83. mfssobject *newmfssobject(FSSpec *fss); /* Forward */
  84.  
  85. /* ---------------------------------------------------------------- */
  86.  
  87. static object *
  88. mfsa_Resolve(self, args)
  89.     mfsaobject *self;
  90.     object *args;
  91. {
  92.     FSSpec from, *fromp, result;
  93.     Boolean changed;
  94.     OSErr err;
  95.     
  96.     from.name[0] = 0;
  97.     if (!newgetargs(args, "|O&", PyMac_GetFSSpec, &from))
  98.         return NULL;
  99.     if (from.name[0] )
  100.         fromp = &from;
  101.     else
  102.         fromp = NULL;
  103.     err = ResolveAlias(fromp, self->alias, &result, &changed);
  104.     if ( err ) {
  105.         PyErr_Mac(ErrorObject, err);
  106.         return NULL;
  107.     }
  108.     return mkvalue("(Oi)", newmfssobject(&result), (int)changed);
  109. }
  110.  
  111. static object *
  112. mfsa_GetInfo(self, args)
  113.     mfsaobject *self;
  114.     object *args;
  115. {
  116.     Str63 value;
  117.     int i;
  118.     OSErr err;
  119.     
  120.     if (!newgetargs(args, "i", &i))
  121.         return NULL;
  122.     err = GetAliasInfo(self->alias, (AliasInfoType)i, value);
  123.     if ( err ) {
  124.         PyErr_Mac(ErrorObject, err);
  125.         return 0;
  126.     }
  127.     return newsizedstringobject((char *)&value[1], value[0]);
  128. }
  129.  
  130. static object *
  131. mfsa_Update(self, args)
  132.     mfsaobject *self;
  133.     object *args;
  134. {
  135.     FSSpec target, fromfile, *fromfilep;
  136.     OSErr err;
  137.     Boolean changed;
  138.     
  139.     fromfile.name[0] = 0;
  140.     if (!newgetargs(args, "O&|O&",  PyMac_GetFSSpec, &target,
  141.                      PyMac_GetFSSpec, &fromfile))
  142.         return NULL;
  143.     if ( fromfile.name[0] )
  144.         fromfilep = &fromfile;
  145.     else
  146.         fromfilep = NULL;
  147.     err = UpdateAlias(fromfilep, &target, self->alias, &changed);
  148.     if ( err ) {
  149.         PyErr_Mac(ErrorObject, err);
  150.         return 0;
  151.     }
  152.     return mkvalue("i", (int)changed);
  153. }
  154.  
  155. static struct methodlist mfsa_methods[] = {
  156.     {"Resolve",    (method)mfsa_Resolve,    1},
  157.     {"GetInfo",    (method)mfsa_GetInfo,    1},
  158.     {"Update",    (method)mfsa_Update,    1},
  159.  
  160.     {NULL,        NULL}        /* sentinel */
  161. };
  162.  
  163. /* ---------- */
  164.  
  165. static object *
  166. mfsa_getattr(self, name)
  167.     mfsaobject *self;
  168.     char *name;
  169. {
  170.     if ( strcmp(name, "data") == 0 ) {
  171.         int size;
  172.         PyObject *rv;
  173.         
  174.         size = GetHandleSize((Handle)self->alias);
  175.         HLock((Handle)self->alias);
  176.         rv = PyString_FromStringAndSize(*(Handle)self->alias, size);
  177.         HUnlock((Handle)self->alias);
  178.         return rv;
  179.     }
  180.     return findmethod(mfsa_methods, (object *)self, name);
  181. }
  182.  
  183. mfsaobject *
  184. newmfsaobject(alias)
  185.     AliasHandle alias;
  186. {
  187.     mfsaobject *self;
  188.  
  189.     self = NEWOBJ(mfsaobject, &Mfsatype);
  190.     if (self == NULL)
  191.         return NULL;
  192.     self->alias = alias;
  193.     return self;
  194. }
  195.  
  196.  
  197. static void
  198. mfsa_dealloc(self)
  199.     mfsaobject *self;
  200. {
  201. #if 0
  202.     if ( self->alias ) {
  203.         should we do something here?
  204.     }
  205. #endif
  206.         
  207.     DEL(self);
  208. }
  209.  
  210. statichere typeobject Mfsatype = {
  211.     OB_HEAD_INIT(&Typetype)
  212.     0,                /*ob_size*/
  213.     "Alias",            /*tp_name*/
  214.     sizeof(mfsaobject),        /*tp_basicsize*/
  215.     0,                /*tp_itemsize*/
  216.     /* methods */
  217.     (destructor)mfsa_dealloc,    /*tp_dealloc*/
  218.     (printfunc)0,            /*tp_print*/
  219.     (getattrfunc)mfsa_getattr,    /*tp_getattr*/
  220.     (setattrfunc)0,            /*tp_setattr*/
  221.     (cmpfunc)0,            /*tp_compare*/
  222.     (reprfunc)0,            /*tp_repr*/
  223.     0,                /*tp_as_number*/
  224.     0,                /*tp_as_sequence*/
  225.     0,                /*tp_as_mapping*/
  226.     (hashfunc)0,            /*tp_hash*/
  227. };
  228.  
  229. /* End of code for Alias objects */
  230. /* -------------------------------------------------------- */
  231.  
  232. /* ---------------------------------------------------------------- */
  233.  
  234. static struct methodlist mfsi_methods[] = {
  235.     
  236.     {NULL,        NULL}        /* sentinel */
  237. };
  238.  
  239. /* ---------- */
  240.  
  241. static mfsiobject *
  242. newmfsiobject()
  243. {
  244.     mfsiobject *self;
  245.     
  246.     self = NEWOBJ(mfsiobject, &Mfsitype);
  247.     if (self == NULL)
  248.         return NULL;
  249.     memset((char *)&self->finfo, '\0', sizeof(self->finfo));
  250.     return self;
  251. }
  252.  
  253. static void
  254. mfsi_dealloc(self)
  255.     mfsiobject *self;
  256. {
  257.     DEL(self);
  258. }
  259.  
  260. static object *
  261. mfsi_getattr(self, name)
  262.     mfsiobject *self;
  263.     char *name;
  264. {
  265.     if ( strcmp(name, "Type") == 0 )
  266.         return PyMac_BuildOSType(self->finfo.fdType);
  267.     else if ( strcmp(name, "Creator") == 0 )
  268.         return PyMac_BuildOSType(self->finfo.fdCreator);
  269.     else if ( strcmp(name, "Flags") == 0 )
  270.         return Py_BuildValue("i", (int)self->finfo.fdFlags);
  271.     else if ( strcmp(name, "Location") == 0 )
  272.         return PyMac_BuildPoint(self->finfo.fdLocation);
  273.     else if ( strcmp(name, "Fldr") == 0 )
  274.         return Py_BuildValue("i", (int)self->finfo.fdFldr);
  275.     else
  276.         return findmethod(mfsi_methods, (object *)self, name);
  277. }
  278.  
  279.  
  280. static int
  281. mfsi_setattr(self, name, v)
  282.     mfsiobject *self;
  283.     char *name;
  284.     object *v;
  285. {
  286.     int rv;
  287.     int i;
  288.     
  289.     if ( v == NULL ) {
  290.         err_setstr(AttributeError, "Cannot delete attribute");
  291.         return -1;
  292.     }
  293.     if ( strcmp(name, "Type") == 0 )
  294.         rv = PyMac_GetOSType(v, &self->finfo.fdType);
  295.     else if ( strcmp(name, "Creator") == 0 )
  296.         rv = PyMac_GetOSType(v, &self->finfo.fdCreator);
  297.     else if ( strcmp(name, "Flags") == 0 ) {
  298.         rv = PyArg_Parse(v, "i", &i);
  299.         self->finfo.fdFlags = (short)i;
  300.     } else if ( strcmp(name, "Location") == 0 )
  301.         rv = PyMac_GetPoint(v, &self->finfo.fdLocation);
  302.     else if ( strcmp(name, "Fldr") == 0 ) {
  303.         rv = PyArg_Parse(v, "i", &i);
  304.         self->finfo.fdFldr = (short)i;
  305.     } else {
  306.         err_setstr(AttributeError, "No such attribute");
  307.         return -1;
  308.     }
  309.     if (rv)
  310.         return 0;
  311.     return -1;
  312. }
  313.  
  314.  
  315. static typeobject Mfsitype = {
  316.     OB_HEAD_INIT(&Typetype)
  317.     0,                /*ob_size*/
  318.     "FInfo object",            /*tp_name*/
  319.     sizeof(mfsiobject),        /*tp_basicsize*/
  320.     0,                /*tp_itemsize*/
  321.     /* methods */
  322.     (destructor)mfsi_dealloc,    /*tp_dealloc*/
  323.     (printfunc)0,        /*tp_print*/
  324.     (getattrfunc)mfsi_getattr,    /*tp_getattr*/
  325.     (setattrfunc)mfsi_setattr,    /*tp_setattr*/
  326.     (cmpfunc)0,        /*tp_compare*/
  327.     (reprfunc)0,        /*tp_repr*/
  328.     0,            /*tp_as_number*/
  329.     0,        /*tp_as_sequence*/
  330.     0,        /*tp_as_mapping*/
  331.     (hashfunc)0,        /*tp_hash*/
  332. };
  333.  
  334. /* End of code for FInfo object objects */
  335. /* -------------------------------------------------------- */
  336.  
  337.  
  338. /*
  339. ** Helper routine for other modules: return an FSSpec * if the
  340. ** object is a python fsspec object, else NULL
  341. */
  342. FSSpec *
  343. mfs_GetFSSpecFSSpec(self)
  344.     object *self;
  345. {
  346.     if ( is_mfssobject(self) )
  347.         return &((mfssobject *)self)->fsspec;
  348.     return NULL;
  349. }
  350.  
  351. /*
  352. ** Two generally useful routines
  353. */
  354. static OSErr
  355. PyMac_GetFileDates(fss, crdat, mddat, bkdat)
  356.     FSSpec *fss;
  357.     unsigned long *crdat, *mddat, *bkdat;
  358. {
  359.     CInfoPBRec pb;
  360.     OSErr error;
  361.     
  362.     pb.dirInfo.ioNamePtr = fss->name;
  363.     pb.dirInfo.ioFDirIndex = 0;
  364.     pb.dirInfo.ioVRefNum = fss->vRefNum;
  365.     pb.dirInfo.ioDrDirID = fss->parID;
  366.     error = PBGetCatInfoSync(&pb);
  367.     if ( error ) return error;
  368.     *crdat = pb.hFileInfo.ioFlCrDat;
  369.     *mddat = pb.hFileInfo.ioFlMdDat;
  370.     *bkdat = pb.hFileInfo.ioFlBkDat;
  371.     return 0;
  372. }    
  373.  
  374. static OSErr
  375. PyMac_SetFileDates(fss, crdat, mddat, bkdat)
  376.     FSSpec *fss;
  377.     unsigned long crdat, mddat, bkdat;
  378. {
  379.     CInfoPBRec pb;
  380.     OSErr error;
  381.     
  382.     pb.dirInfo.ioNamePtr = fss->name;
  383.     pb.dirInfo.ioFDirIndex = 0;
  384.     pb.dirInfo.ioVRefNum = fss->vRefNum;
  385.     pb.dirInfo.ioDrDirID = fss->parID;
  386.     error = PBGetCatInfoSync(&pb);
  387.     if ( error ) return error;
  388.     pb.dirInfo.ioNamePtr = fss->name;
  389.     pb.dirInfo.ioFDirIndex = 0;
  390.     pb.dirInfo.ioVRefNum = fss->vRefNum;
  391.     pb.dirInfo.ioDrDirID = fss->parID;
  392.     pb.hFileInfo.ioFlCrDat = crdat;
  393.     pb.hFileInfo.ioFlMdDat = mddat;
  394.     pb.hFileInfo.ioFlBkDat = bkdat;
  395.     error = PBSetCatInfoSync(&pb);
  396.     return error;
  397. }
  398.  
  399. static object *
  400. mfss_as_pathname(self, args)
  401.     mfssobject *self;
  402.     object *args;
  403. {
  404.     char strbuf[257];
  405.     OSErr err;
  406.  
  407.     if (!newgetargs(args, ""))
  408.         return NULL;
  409.     err = nfullpath(&self->fsspec, strbuf);
  410.     if ( err ) {
  411.         PyErr_Mac(ErrorObject, err);
  412.         return NULL;
  413.     }
  414.     return newstringobject(strbuf);
  415. }
  416.  
  417. static object *
  418. mfss_as_tuple(self, args)
  419.     mfssobject *self;
  420.     object *args;
  421. {
  422.     if (!newgetargs(args, ""))
  423.         return NULL;
  424.     return Py_BuildValue("(iis#)", self->fsspec.vRefNum, self->fsspec.parID, 
  425.                         &self->fsspec.name[1], self->fsspec.name[0]);
  426. }
  427.  
  428. static object *
  429. mfss_NewAlias(self, args)
  430.     mfssobject *self;
  431.     object *args;
  432. {
  433.     FSSpec src, *srcp;
  434.     OSErr err;
  435.     AliasHandle alias;
  436.     
  437.     src.name[0] = 0;
  438.     if (!newgetargs(args, "|O&", PyMac_GetFSSpec, &src))
  439.         return NULL;
  440.     if ( src.name[0] )
  441.         srcp = &src;
  442.     else
  443.         srcp = NULL;
  444.     err = NewAlias(srcp, &self->fsspec, &alias);
  445.     if ( err ) {
  446.         PyErr_Mac(ErrorObject, err);
  447.         return NULL;
  448.     }
  449.     
  450.     return (object *)newmfsaobject(alias);
  451. }
  452.  
  453. static object *
  454. mfss_NewAliasMinimal(self, args)
  455.     mfssobject *self;
  456.     object *args;
  457. {
  458.     OSErr err;
  459.     AliasHandle alias;
  460.     
  461.     if (!newgetargs(args, ""))
  462.         return NULL;
  463.     err = NewAliasMinimal(&self->fsspec, &alias);
  464.     if ( err ) {
  465.         PyErr_Mac(ErrorObject, err);
  466.         return NULL;
  467.     }
  468.     return (object *)newmfsaobject(alias);
  469. }
  470.  
  471. /* XXXX These routines should be replaced by a wrapper to the *FInfo routines */
  472. static object *
  473. mfss_GetCreatorType(self, args)
  474.     mfssobject *self;
  475.     object *args;
  476. {
  477.     OSErr err;
  478.     FInfo info;
  479.     
  480.     if (!newgetargs(args, ""))
  481.         return NULL;
  482.     err = FSpGetFInfo(&self->fsspec, &info);
  483.     if ( err ) {
  484.         PyErr_Mac(ErrorObject, err);
  485.         return NULL;
  486.     }
  487.     return Py_BuildValue("(O&O&)",
  488.                PyMac_BuildOSType, info.fdCreator, PyMac_BuildOSType, info.fdType);
  489. }
  490.  
  491. static object *
  492. mfss_SetCreatorType(self, args)
  493.     mfssobject *self;
  494.     object *args;
  495. {
  496.     OSErr err;
  497.     OSType creator, type;
  498.     FInfo info;
  499.     
  500.     if (!newgetargs(args, "O&O&", PyMac_GetOSType, &creator, PyMac_GetOSType, &type))
  501.         return NULL;
  502.     err = FSpGetFInfo(&self->fsspec, &info);
  503.     if ( err ) {
  504.         PyErr_Mac(ErrorObject, err);
  505.         return NULL;
  506.     }
  507.     info.fdType = type;
  508.     info.fdCreator = creator;
  509.     err = FSpSetFInfo(&self->fsspec, &info);
  510.     if ( err ) {
  511.         PyErr_Mac(ErrorObject, err);
  512.         return NULL;
  513.     }
  514.     INCREF(None);
  515.     return None;
  516. }
  517.  
  518. static object *
  519. mfss_GetFInfo(self, args)
  520.     mfssobject *self;
  521.     object *args;
  522. {
  523.     OSErr err;
  524.     mfsiobject *fip;
  525.     
  526.     
  527.     if (!newgetargs(args, ""))
  528.         return NULL;
  529.     if ( (fip=newmfsiobject()) == NULL )
  530.         return NULL;
  531.     err = FSpGetFInfo(&self->fsspec, &fip->finfo);
  532.     if ( err ) {
  533.         PyErr_Mac(ErrorObject, err);
  534.         DECREF(fip);
  535.         return NULL;
  536.     }
  537.     return (object *)fip;
  538. }
  539.  
  540. static object *
  541. mfss_SetFInfo(self, args)
  542.     mfssobject *self;
  543.     object *args;
  544. {
  545.     OSErr err;
  546.     mfsiobject *fip;
  547.     
  548.     if (!newgetargs(args, "O!", &Mfsitype, &fip))
  549.         return NULL;
  550.     err = FSpSetFInfo(&self->fsspec, &fip->finfo);
  551.     if ( err ) {
  552.         PyErr_Mac(ErrorObject, err);
  553.         return NULL;
  554.     }
  555.     INCREF(None);
  556.     return None;
  557. }
  558.  
  559. static object *
  560. mfss_GetDates(self, args)
  561.     mfssobject *self;
  562.     object *args;
  563. {
  564.     OSErr err;
  565.     unsigned long crdat, mddat, bkdat;
  566.     
  567.     if (!newgetargs(args, ""))
  568.         return NULL;
  569.     err = PyMac_GetFileDates(&self->fsspec, &crdat, &mddat, &bkdat);
  570.     if ( err ) {
  571.         PyErr_Mac(ErrorObject, err);
  572.         return NULL;
  573.     }
  574.     return mkvalue("ddd", (double)crdat, (double)mddat, (double)bkdat);
  575. }
  576.  
  577. static object *
  578. mfss_SetDates(self, args)
  579.     mfssobject *self;
  580.     object *args;
  581. {
  582.     OSErr err;
  583.     double crdat, mddat, bkdat;
  584.     
  585.     if (!newgetargs(args, "ddd", &crdat, &mddat, &bkdat))
  586.         return NULL;
  587.     err = PyMac_SetFileDates(&self->fsspec, (unsigned long)crdat, 
  588.                 (unsigned long)mddat, (unsigned long)bkdat);
  589.     if ( err ) {
  590.         PyErr_Mac(ErrorObject, err);
  591.         return NULL;
  592.     }
  593.     INCREF(None);
  594.     return None;
  595. }
  596.  
  597. static struct methodlist mfss_methods[] = {
  598.     {"as_pathname",        (method)mfss_as_pathname,            1},
  599.     {"as_tuple",        (method)mfss_as_tuple,                1},
  600.     {"NewAlias",        (method)mfss_NewAlias,                1},
  601.     {"NewAliasMinimal",    (method)mfss_NewAliasMinimal,        1},
  602.     {"GetCreatorType",    (method)mfss_GetCreatorType,        1},
  603.     {"SetCreatorType",    (method)mfss_SetCreatorType,        1},
  604.     {"GetFInfo",        (method)mfss_GetFInfo,                1},
  605.     {"SetFInfo",        (method)mfss_SetFInfo,                1},
  606.     {"GetDates",        (method)mfss_GetDates,                1},
  607.     {"SetDates",        (method)mfss_SetDates,                1},
  608.  
  609.     {NULL,            NULL}        /* sentinel */
  610. };
  611.  
  612. /* ---------- */
  613.  
  614. static object *
  615. mfss_getattr(self, name)
  616.     mfssobject *self;
  617.     char *name;
  618. {
  619.     if ( strcmp(name, "data") == 0)
  620.         return PyString_FromStringAndSize((char *)&self->fsspec, sizeof(FSSpec));    
  621.     return findmethod(mfss_methods, (object *)self, name);
  622. }
  623.  
  624. mfssobject *
  625. newmfssobject(fss)
  626.     FSSpec *fss;
  627. {
  628.     mfssobject *self;
  629.     
  630.     self = NEWOBJ(mfssobject, &Mfsstype);
  631.     if (self == NULL)
  632.         return NULL;
  633.     self->fsspec = *fss;
  634.     return self;
  635. }
  636.  
  637. static void
  638. mfss_dealloc(self)
  639.     mfssobject *self;
  640. {
  641.     DEL(self);
  642. }
  643.  
  644. static object *
  645. mfss_repr(self)
  646.     mfssobject *self;
  647. {
  648.     char buf[512];
  649.  
  650.     sprintf(buf, "FSSpec((%d, %d, '%.*s'))",
  651.         self->fsspec.vRefNum, 
  652.         self->fsspec.parID,
  653.         self->fsspec.name[0], self->fsspec.name+1);
  654.     return newstringobject(buf);
  655. }
  656.  
  657. static int
  658. mfss_compare(v, w)
  659.     mfssobject *v, *w;
  660. {
  661.     int minlen;
  662.     int res;
  663.     
  664.     if ( v->fsspec.vRefNum < w->fsspec.vRefNum ) return -1;
  665.     if ( v->fsspec.vRefNum > w->fsspec.vRefNum ) return 1;
  666.     if ( v->fsspec.parID < w->fsspec.parID ) return -1;
  667.     if ( v->fsspec.parID > w->fsspec.parID ) return 1;
  668.     minlen = v->fsspec.name[0];
  669.     if ( w->fsspec.name[0] < minlen ) minlen = w->fsspec.name[0];
  670.     res = strncmp((char *)v->fsspec.name+1, (char *)w->fsspec.name+1, minlen);
  671.     if ( res ) return res;
  672.     if ( v->fsspec.name[0] < w->fsspec.name[0] ) return -1;
  673.     if ( v->fsspec.name[0] > w->fsspec.name[0] ) return 1;
  674.     return res;
  675. }
  676.  
  677. statichere typeobject Mfsstype = {
  678.     OB_HEAD_INIT(&Typetype)
  679.     0,                /*ob_size*/
  680.     "FSSpec",            /*tp_name*/
  681.     sizeof(mfssobject),        /*tp_basicsize*/
  682.     0,                /*tp_itemsize*/
  683.     /* methods */
  684.     (destructor)mfss_dealloc,    /*tp_dealloc*/
  685.     (printfunc)0,        /*tp_print*/
  686.     (getattrfunc)mfss_getattr,    /*tp_getattr*/
  687.     (setattrfunc)0,    /*tp_setattr*/
  688.     (cmpfunc)mfss_compare,        /*tp_compare*/
  689.     (reprfunc)mfss_repr,        /*tp_repr*/
  690.     0,            /*tp_as_number*/
  691.     0,        /*tp_as_sequence*/
  692.     0,        /*tp_as_mapping*/
  693.     (hashfunc)0,        /*tp_hash*/
  694. };
  695.  
  696. /* End of code for FSSpec objects */
  697. /* -------------------------------------------------------- */
  698.  
  699. static object *
  700. mfs_ResolveAliasFile(self, args)
  701.     object *self;    /* Not used */
  702.     object *args;
  703. {
  704.     FSSpec fss;
  705.     Boolean chain = 1, isfolder, wasaliased;
  706.     OSErr err;
  707.  
  708.     if (!newgetargs(args, "O&|i", PyMac_GetFSSpec, &fss, &chain))
  709.         return NULL;
  710.     err = ResolveAliasFile(&fss, chain, &isfolder, &wasaliased);
  711.     if ( err ) {
  712.         PyErr_Mac(ErrorObject, err);
  713.         return NULL;
  714.     }
  715.     return mkvalue("Oii", newmfssobject(&fss), (int)isfolder, (int)wasaliased);
  716. }
  717.  
  718. static object *
  719. mfs_StandardGetFile(self, args)
  720.     object *self;    /* Not used */
  721.     object *args;
  722. {
  723.     SFTypeList list;
  724.     short numtypes;
  725.     StandardFileReply reply;
  726.     
  727.     list[0] = list[1] = list[2] = list[3] = 0;
  728.     numtypes = 0;
  729.     if (!newgetargs(args, "|O&O&O&O&", PyMac_GetOSType, &list[0],
  730.              PyMac_GetOSType, &list[1], PyMac_GetOSType, &list[2],
  731.               PyMac_GetOSType, &list[3]) )
  732.         return NULL;
  733.     while ( numtypes < 4 && list[numtypes] ) {
  734.         numtypes++;
  735.     }
  736.     if ( numtypes == 0 )
  737.         numtypes = -1;
  738.     StandardGetFile((FileFilterUPP)0, numtypes, list, &reply);
  739.     return mkvalue("(Oi)", newmfssobject(&reply.sfFile), reply.sfGood);
  740. }
  741.  
  742. static object *
  743. mfs_PromptGetFile(self, args)
  744.     object *self;    /* Not used */
  745.     object *args;
  746. {
  747.     SFTypeList list;
  748.     short numtypes;
  749.     StandardFileReply reply;
  750.     char *prompt = NULL;
  751.     
  752.     list[0] = list[1] = list[2] = list[3] = 0;
  753.     numtypes = 0;
  754.     if (!newgetargs(args, "s|O&O&O&O&", &prompt, PyMac_GetOSType, &list[0],
  755.              PyMac_GetOSType, &list[1], PyMac_GetOSType, &list[2],
  756.               PyMac_GetOSType, &list[3]) )
  757.         return NULL;
  758.     while ( numtypes < 4 && list[numtypes] ) {
  759.         numtypes++;
  760.     }
  761.     if ( numtypes == 0 )
  762.         numtypes = -1;
  763.     PyMac_PromptGetFile(numtypes, list, &reply, prompt);
  764.     return mkvalue("(Oi)", newmfssobject(&reply.sfFile), reply.sfGood);
  765. }
  766.  
  767. static object *
  768. mfs_StandardPutFile(self, args)
  769.     object *self;    /* Not used */
  770.     object *args;
  771. {
  772.     Str255 prompt, dft;
  773.     StandardFileReply reply;
  774.     
  775.     dft[0] = 0;
  776.     if (!newgetargs(args, "O&|O&", PyMac_GetStr255, &prompt, PyMac_GetStr255, &dft) )
  777.         return NULL;
  778.     StandardPutFile(prompt, dft, &reply);
  779.     return mkvalue("(Oi)",newmfssobject(&reply.sfFile), reply.sfGood);
  780. }
  781.  
  782. /*
  783. ** Set initial directory for file dialogs */
  784. static object *
  785. mfs_SetFolder(self, args)
  786.     object *self;
  787.     object *args;
  788. {
  789.     FSSpec spec;
  790.     FSSpec ospec;
  791.     short orefnum;
  792.     long oparid;
  793.     
  794.     /* Get old values */
  795.     orefnum = -LMGetSFSaveDisk();
  796.     oparid = LMGetCurDirStore();
  797.     (void)FSMakeFSSpec(orefnum, oparid, "\pplaceholder", &ospec);
  798.     
  799.     /* Go to working directory by default */
  800.     (void)FSMakeFSSpec(0, 0, "\p:placeholder", &spec);
  801.     if (!newgetargs(args, "|O&", PyMac_GetFSSpec, &spec))
  802.         return NULL;
  803.     /* Set standard-file working directory */
  804.     LMSetSFSaveDisk(-spec.vRefNum);
  805.     LMSetCurDirStore(spec.parID);
  806.     return (object *)newmfssobject(&ospec);
  807. }
  808.  
  809. static object *
  810. mfs_FSSpec(self, args)
  811.     object *self;    /* Not used */
  812.     object *args;
  813. {
  814.     FSSpec fss;
  815.  
  816.     if (!newgetargs(args, "O&", PyMac_GetFSSpec, &fss))
  817.         return NULL;
  818.     return (object *)newmfssobject(&fss);
  819. }
  820.  
  821. static object *
  822. mfs_RawFSSpec(self, args)
  823.     object *self;    /* Not used */
  824.     object *args;
  825. {
  826.     FSSpec *fssp;
  827.     int size;
  828.  
  829.     if (!newgetargs(args, "s#", &fssp, &size))
  830.         return NULL;
  831.     if ( size != sizeof(FSSpec) ) {
  832.         PyErr_SetString(PyExc_TypeError, "Incorrect size for FSSpec record");
  833.         return NULL;
  834.     }
  835.     return (object *)newmfssobject(fssp);
  836. }
  837.  
  838. static object *
  839. mfs_RawAlias(self, args)
  840.     object *self;    /* Not used */
  841.     object *args;
  842. {
  843.     char *dataptr;
  844.     Handle h;
  845.     int size;
  846.  
  847.     if (!newgetargs(args, "s#", &dataptr, &size))
  848.         return NULL;
  849.     h = NewHandle(size);
  850.     if ( h == NULL ) {
  851.         PyErr_NoMemory();
  852.         return NULL;
  853.     }
  854.     HLock(h);
  855.     memcpy((char *)*h, dataptr, size);
  856.     HUnlock(h);
  857.     return (object *)newmfsaobject((AliasHandle)h);
  858. }
  859.  
  860. static object *
  861. mfs_GetDirectory(self, args)
  862.     object *self;    /* Not used */
  863.     object *args;
  864. {
  865.     FSSpec fsdir;
  866.     int ok;
  867.     char *prompt = NULL;
  868.         
  869.     if (!newgetargs(args, "|s", &prompt) )
  870.         return NULL;
  871.         
  872.     ok = PyMac_GetDirectory(&fsdir, prompt);
  873.     return mkvalue("(Oi)", newmfssobject(&fsdir), ok);
  874. }
  875.  
  876. static object *
  877. mfs_FindFolder(self, args)
  878.     object *self;    /* Not used */
  879.     object *args;
  880. {
  881.     OSErr err;
  882.     short where;
  883.     OSType which;
  884.     int create;
  885.     short refnum;
  886.     long dirid;
  887.         
  888.     if (!newgetargs(args, "hO&i", &where, PyMac_GetOSType, &which, &create) )
  889.         return NULL;
  890.     err = FindFolder(where, which, (Boolean)create, &refnum, &dirid);
  891.     if ( err ) {
  892.         PyErr_Mac(ErrorObject, err);
  893.         return NULL;
  894.     }
  895.     return mkvalue("(ii)", refnum, dirid);
  896. }
  897.  
  898. static object *
  899. mfs_FindApplication(self, args)
  900.     object *self;    /* Not used */
  901.     object *args;
  902. {
  903.     OSErr err;
  904.     OSType which;
  905.     FSSpec    fss;
  906.         
  907.     if (!newgetargs(args, "O&", PyMac_GetOSType, &which) )
  908.         return NULL;
  909.     err = FindApplicationFromCreator(which, &fss);
  910.     if ( err ) {
  911.         PyErr_Mac(ErrorObject, err);
  912.         return NULL;
  913.     }
  914.     return (object *)newmfssobject(&fss);
  915. }
  916.  
  917. static object *
  918. mfs_FInfo(self, args)
  919.     object *self;
  920.     object *args;
  921. {    
  922.     return (object *)newmfsiobject();
  923. }
  924.  
  925. /* List of methods defined in the module */
  926.  
  927. static struct methodlist mfs_methods[] = {
  928.     {"ResolveAliasFile",    mfs_ResolveAliasFile,    1},
  929.     {"StandardGetFile",        mfs_StandardGetFile,    1},
  930.     {"PromptGetFile",        mfs_PromptGetFile,        1},
  931.     {"StandardPutFile",        mfs_StandardPutFile,    1},
  932.     {"GetDirectory",        mfs_GetDirectory,        1},
  933.     {"SetFolder",            mfs_SetFolder,            1},
  934.     {"FSSpec",                mfs_FSSpec,                1},
  935.     {"RawFSSpec",            mfs_RawFSSpec,            1},
  936.     {"RawAlias",            mfs_RawAlias,            1},
  937.     {"FindFolder",            mfs_FindFolder,            1},
  938.     {"FindApplication",        mfs_FindApplication,    1},
  939.     {"FInfo",                mfs_FInfo,                1},
  940.  
  941.     {NULL,        NULL}        /* sentinel */
  942. };
  943.  
  944.  
  945. /* Initialization function for the module (*must* be called initmacfs) */
  946.  
  947. void
  948. initmacfs()
  949. {
  950.     object *m, *d;
  951.  
  952.     /* Create the module and add the functions */
  953.     m = initmodule("macfs", mfs_methods);
  954.  
  955.     /* Add some symbolic constants to the module */
  956.     d = getmoduledict(m);
  957.     ErrorObject = newstringobject("macfs.error");
  958.     dictinsert(d, "error", ErrorObject);
  959.  
  960.     /* XXXX Add constants here */
  961.     
  962.     /* Check for errors */
  963.     if (err_occurred())
  964.         fatal("can't initialize module macfs");
  965. }
  966.